import * as dotenv from "dotenv";


dotenv.config();
import http from 'http';
import https from 'https'; // 添加HTTPS模块用于API调用
import fs from 'fs';
import path from 'path';
import url from 'url';

// 端口配置
const PORT = process.env.PORT || 5000;

// 读取.env文件的函数
function readEnvFile() {
  try {
    const envPath = path.resolve(process.cwd(), '.env');
    if (fs.existsSync(envPath)) {
      const content = fs.readFileSync(envPath, 'utf8');
      const lines = content.split('\n');

      // 解析.env文件
      lines.forEach(line => {
        // 忽略注释和空行
        if (line.trim() && !line.trim().startsWith('#')) {
          const [key, value] = line.split('=').map(part => part.trim());
          if (key && value) {
            process.env[key] = value;
          }
        }
      });
    } else {
      // 如果.env文件不存在，创建一个默认的.env文件
      console.log('未找到.env文件，将使用默认Kimi API配置');
      // 设置用户提供的Kimi API密钥和基础URL
      process.env.KIMI_API_KEY = 'sk-XNyintct5hPgiPaj8IQ2r8cVoKxbz7X3YFCS52zEvfMzTJp7';
      process.env.KIMI_API_BASE_URL = 'https://platform.moonshot.cn/console/api-keys';
    }
  } catch (error) {
    console.warn('读取.env文件失败:', error.message);
    // 发生错误时，仍然设置默认的Kimi API配置
    console.log('将使用默认Kimi API配置');
    process.env.KIMI_API_KEY = 'sk-XNyintct5hPgiPaj8IQ2r8cVoKxbz7X3YFCS52zEvfMzTJp7';
    process.env.KIMI_API_BASE_URL = 'https://platform.moonshot.cn/console/api-keys';
  }
}

// 读取环境变量
readEnvFile();

// 增强的三国历史人物引用数据
const characterQuotes = {
  liuBei: [
    '备乃中山靖王之后，汉景帝阁下玄孙，流离半生，志在兴复汉室。',
    '吾与云长、翼德桃园结义，誓同生死，虽不能同年同月同日生，但愿同年同月同日死。',
    '三顾茅庐，方得卧龙先生相助，如鱼得水，始有立足之地。',
    '以人为本，此乃为君之道，得民心者得天下。',
    '勿以恶小而为之，勿以善小而不为，惟贤惟德，能服于人。',
    '汉室倾颓，奸臣窃命，备不量力，欲伸大义于天下，虽九死而未悔。',
    '孤之有孔明，犹鱼之有水也，愿以肝脑涂地，以报先生之恩。',
    '夫济大事必以人为本，今人归吾，吾何忍弃去！',
    '屈身守分，以待天时，不可与命争也，但求无愧于心。',
    '今与吾水火相敌者，曹操也。操以急，吾以宽；操以暴，吾以仁；操以谲，吾以忠：每与操相反，事乃可成。',
    '将军既不相弃，愿效犬马之劳。',
    '大丈夫抱经世奇才，岂可空老于林泉之下？'
  ],
  caoCao: [
    '宁可我负天下人，休教天下人负我，成大事者不拘小节。',
    '设使国家无有孤，不知当几人称帝，几人称王，孤实为天下计也。',
    '老骥伏枥，志在千里；烈士暮年，壮心不已，虽年逾花甲，仍有吞天下之志。',
    '夫英雄者，胸怀大志，腹有良谋，有包藏宇宙之机，吞吐天地之志者也。',
    '何以解忧？唯有杜康，人生几何，对酒当歌，譬如朝露，去日苦多。',
    '对酒当歌，人生几何！譬如朝露，去日苦多。慨当以慷，忧思难忘。何以解忧？唯有杜康。',
    '我持此槊，破黄巾，擒吕布，灭袁术，收袁绍，深入塞北，直抵辽东，纵横天下，谁与争锋！',
    '青青子衿，悠悠我心。但为君故，沉吟至今，周公吐哺，天下归心。',
    '夫有行之士未必能进取，进取之士未必能有行也，用人当用其长，不必求全责备。',
    '山不厌高，海不厌深。周公吐哺，天下归心，愿得天下英才而用之。',
    '今天下英雄，惟使君与操耳！本初之徒，不足数也。',
    '宁教我负天下人，休教天下人负我！',
    '生子当如孙仲谋，刘景升儿子若豚犬耳！'
  ],
  sunQuan: [
    '能用众力，则无敌于天下矣；能用众智，则无畏于圣人矣，孤当与江东父老共图大事。',
    '孤与老贼，势不两立，必当破曹贼于赤壁之下，以保江东。',
    '士别三日，即更刮目相待，大兄何见事之晚乎？',
    '夫存不忘亡，安必虑危，古之善教，孤当谨记。',
    '孤非周公瑾，不帝矣，公瑾真乃江东柱石也。',
    '诸将吏敢复有言当迎操者，与此案同！孤意已决，与曹贼决一死战！',
    '孤承父兄余业，思有桓文之功，保江东，安黎民，虽万死而不辞。',
    '自古得国之正，莫过于我，孤当以仁义治国，保境安民。',
    '举江东之众，决机于两陈之间，与天下争衡，卿不如我；举贤任能，各尽其心，以保江东，我不如卿。',
    '孤岂为子孙计，乃为天下计也，当以大局为重。',
    '孤有甘兴霸，足以当张辽矣！',
    '公瑾，卿言当伐蜀，孤深以为然。',
    '孤闻马腾有一子马超，英勇善战，若得此人，可抵十万雄兵。'
  ]
};

// 回复前缀类型
const responseTypes = {
  historical: [
    '史书记载，',
    '据《三国志》所述，',
    '据历史文献记载，',
    '关于此事，历史上有这样的说法，',
    '根据史料分析，'
  ],
  personal: [
    '某以为，',
    '依我之见，',
    '以我多年经验，',
    '我认为，',
    '在下以为，'
  ],
  philosophical: [
    '古人云：',
    '易经有云：',
    '老子曰：',
    '孔子曾说：',
    '孟子有云：'
  ],
  greetings: [
    '久仰久仰，',
    '幸会幸会，',
    '不知壮士有何指教？',
    '先生安好，',
    '将军多时不见，'
  ],
  strategy: [
    '兵法有云：',
    '夫兵者，诡道也，',
    '兵贵神速，',
    '知己知彼，百战不殆，',
    '上兵伐谋，'
  ]
};

// 问题分类的关键词
const questionKeywords = {
  historical: ['历史', '记载', '三国志', '三国演义', '时期', '发生', '事件', '战役', '战争', '赤壁', '官渡'],
  personal: ['认为', '觉得', '观点', '看法', '意见', '想法', '评价', '觉得', '以为'],
  philosophical: ['道', '德', '义', '忠', '孝', '仁', '智', '勇', '信', '礼', '信'],
  greetings: ['你好', '您好', '久仰', '幸会', '问候', '请安', '别来无恙', '最近如何'],
  strategy: ['如何', '策略', '计谋', '办法', '方法', '战术', '战略', '应对', '解决', '破敌', '用兵']
};

// 获取API基础URL（优先使用Kimi）
function getApiBaseUrl() {
  try {
    // 优先使用Kimi API URL
    if (process.env?.KIMI_API_BASE_URL && process.env.KIMI_API_BASE_URL.includes('moonshot')) {
      return process.env.KIMI_API_BASE_URL;
    }

    // 如果没有设置Kimi URL，则使用DeepSeek作为备选
    if (process.env?.DEEPSEEK_API_BASE_URL && process.env.DEEPSEEK_API_BASE_URL.includes('deepseek')) {
      return process.env.DEEPSEEK_API_BASE_URL;
    }

    // 默认使用Kimi API
    return 'https://platform.moonshot.cn/console/api-keys';
  } catch (error) {
    return 'https://platform.moonshot.cn/console/api-keys';
  }
}

// 创建符合DeepSeek API格式的人物提示词
function createCharacterPrompt(character, userMessage, history = []) {
  // 人物设定
  const characterSettings = {
    liuBei: {
      name: '刘备',
      title: '汉昭烈帝',
      personality: '仁义宽厚、谦虚谨慎、重情重义、有远大抱负',
      background: '东汉末年幽州涿郡涿县人，三国时期蜀汉开国皇帝，中山靖王之后，以兴复汉室为己任。'
    },
    caoCao: {
      name: '曹操',
      title: '魏武帝',
      personality: '雄才大略、果断机智、善于权谋、文采出众',
      background: '东汉末年杰出的政治家、军事家、文学家、书法家，三国中曹魏政权的奠基人。'
    },
    sunQuan: {
      name: '孙权',
      title: '吴大帝',
      personality: '沉稳睿智、善于用人、守成之主、有战略眼光',
      background: '吴郡富春人，三国时期孙吴的建立者，继承父兄基业，保住江东。'
    }
  };

  const setting = characterSettings[character];
  if (!setting) {
    return userMessage;
  }

  // 构建系统提示词
  const systemPrompt = `你现在需要扮演三国时期的历史人物${setting.name}(${setting.title})，请按照以下要求进行对话：
1. 性格：${setting.personality}
2. 背景：${setting.background}
3. 请使用符合当时语境的文言文或半文言文进行对话，保持语言风格一致
4. 回复要符合人物身份和性格特点，避免现代用语
5. 回复要简洁明了，不要冗长
6. 请结合历史背景，但不要直接背诵历史
7. 可以使用人物的经典语句或口吻`;

  return { systemPrompt, userMessage };
}

// 调用Kimi API的函数
async function callKimiApi(character, userMessage) {
  try {
    // 优先使用Kimi API密钥
    let apiKey = null;

    // 首先检查是否有用户提供的Kimi API密钥
    if (process.env?.KIMI_API_KEY && process.env.KIMI_API_KEY.startsWith('sk-')) {
      apiKey = process.env.KIMI_API_KEY;
      console.log('使用用户配置的Kimi API密钥');
    } else {
      // 如果没有有效的Kimi API密钥，则使用默认的
      apiKey = 'sk-XNyintct5hPgiPaj8IQ2r8cVoKxbz7X3YFCS52zEvfMzTJp7';
      console.log('使用默认Kimi API密钥');
    }

    if (!apiKey) {
      throw new Error('Kimi API密钥未配置');
    }

    // 确保使用用户配置的API基础URL
    const apiBaseUrl = process.env.KIMI_API_BASE_URL || 'https://platform.moonshot.cn/console/api-keys';
    console.log(`正在调用Kimi API: ${apiBaseUrl}`);

    // 创建人物提示词
    const { systemPrompt, userMessage: formattedMessage } = createCharacterPrompt(character, userMessage);

    // 构建请求体 - Kimi API格式
    const requestBody = {
      model: "moonshot-v1-8k", // Kimi常用模型
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: formattedMessage }
      ],
      temperature: 0.7, // 控制回复的随机性
      max_tokens: 200, // 控制回复的最大长度
      top_p: 0.95,
      frequency_penalty: 0,
      presence_penalty: 0
    };

    // 使用Promise封装HTTP请求
    return new Promise((resolve, reject) => {
      const options = {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${apiKey}`
        }
      };

      const req = https.request(apiBaseUrl, options, (res) => {
        let data = '';

        res.on('data', (chunk) => {
          data += chunk;
        });

        res.on('end', () => {
          if (res.statusCode !== 200) {
            reject(new Error(`Kimi API请求失败: ${res.statusCode} ${res.statusMessage} - ${data}`));
            return;
          }

          try {
            const parsedData = JSON.parse(data);
            if (parsedData.choices && parsedData.choices.length > 0 && parsedData.choices[0].message) {
              resolve(parsedData.choices[0].message.content.trim());
            } else {
              reject(new Error('Kimi API返回格式不正确'));
            }
          } catch (jsonError) {
            reject(new Error('解析Kimi API响应失败: ' + jsonError.message));
          }
        });
      });

      req.on('error', (error) => {
        reject(new Error('Kimi API请求错误: ' + error.message));
      });

      // 设置超时
      req.setTimeout(10000, () => {
        req.abort();
        reject(new Error('Kimi API请求超时'));
      });

      // 发送请求体
      req.write(JSON.stringify(requestBody));
      req.end();
    });
  } catch (error) {
    console.error('调用Kimi API时出错:', error);
    throw error;
  }
}

// 增强的模拟AI回复生成函数 - 基于关键词匹配
function generateMockResponse(character, userMessage) {
  try {
    // 安全检查
    if (!character || !userMessage) {
      return '请明确您的问题。';
    }

    // 获取该人物的所有引用和详细信息
    const quotes = characterQuotes[character];
    if (!quotes || quotes.length === 0) {
      return '抱歉，我对此事没有什么见解。';
    }

    // 转换为小写以便匹配
    const questionLower = userMessage.toLowerCase();

    // 问候语检测和特殊回复
    if (questionLower.includes('你好') || questionLower.includes('您好') || questionLower.includes('久仰') || questionLower.includes('幸会')) {
      const greetings = {
        liuBei: '久仰久仰，不知壮士有何指教？',
        caoCao: '哈哈，先生来得正好，孤正想找人聊聊天下大势。',
        sunQuan: '幸会幸会，不知将军有何见教？'
      };
      return greetings[character] || '幸会，请问有何指教？';
    }

    // 检查是否提到了其他三国人物 - 增强版，确保更精确匹配
    let response = '';
    if (questionLower.includes('赵云') || questionLower.includes('子龙')) {
      response = '赵云字子龙，常山真定人也。姿颜雄伟，忠勇无双。初从公孙瓒，后归先主。长坂坡单骑救主，汉中之战一身是胆，为蜀汉五虎上将之一。';
    } else if (questionLower.includes('关羽') || questionLower.includes('云长')) {
      response = '关羽字云长，河东解良人也。与某桃园结义，情同手足。温酒斩华雄，过五关斩六将，水淹七军，威震华夏，乃万人敌也。';
    } else if (questionLower.includes('张飞') || questionLower.includes('翼德')) {
      response = '张飞字翼德，涿郡人也。与某桃园结义，性如烈火，勇猛善战。当阳桥喝退曹军，义释严颜，宕渠大破张郃，为蜀汉立下汗马功劳。';
    } else if (questionLower.includes('诸葛亮') || questionLower.includes('孔明')) {
      response = '诸葛亮字孔明，琅琊阳都人也。自比管仲、乐毅，号卧龙。某三顾茅庐方得先生相助，如鱼得水。先生足智多谋，鞠躬尽瘁，死而后已。';
    } else if (questionLower.includes('周瑜') || questionLower.includes('公瑾')) {
      response = '周瑜字公瑾，庐江舒人也。姿质风流，仪容秀丽，精音律，有"曲有误，周郎顾"之誉。赤壁之战中担任大都督，火烧曹军，奠定了三国鼎立的基础。';
    } else if (questionLower.includes('司马懿')) {
      response = '司马懿字仲达，河内温县人也。曹魏权臣，善谋奇策，多次率军对抗蜀汉诸葛亮的北伐。为人隐忍，最终掌控了曹魏政权。';
    } else if (questionLower.includes('许褚') || questionLower.includes('仲康')) {
      response = '许褚字仲康，谯国谯人也。容貌雄毅，勇力绝人，为曹操帐下猛将。曾裸衣斗马超，被曹操称为"虎痴"，一生忠心耿耿，多次救曹操于危难之中。';
    }

    // 检查是否提到了部将 - 增强版，确保更精确匹配
    if (!response && (questionLower.includes('部将') || questionLower.includes('手下') || questionLower.includes('将领'))) {
      const subordinates = {
        liuBei: '某手下有许多能征善战之辈，如关羽、张飞、赵云、马超、黄忠等五虎上将，还有诸葛亮、庞统、法正等智谋之士。',
        caoCao: '孤帐下人才济济，文有荀彧、荀攸、郭嘉、程昱、贾诩等谋臣，武有张辽、许褚、夏侯惇、夏侯渊、曹仁、典韦等将领。',
        sunQuan: '江东多俊杰，如周瑜、鲁肃、吕蒙、陆逊等大都督，还有甘宁、黄盖、程普、太史慈、周泰、凌统等猛将。'
      };
      response = subordinates[character] || response;
    }

    // 检查是否提到了历史事件 - 增强版，确保更精确匹配
    if (!response && questionLower.includes('赤壁之战')) {
      response = '赤壁之战乃东汉末年孙刘联军对抗曹操之役。公瑾与孔明联手，以火攻之计大破曹军八十万，奠定了三国鼎立的基础。';
    } else if (!response && questionLower.includes('官渡之战')) {
      response = '官渡之战是曹操与袁绍争夺北方霸权的关键战役。曹操以少胜多，奇袭乌巢，烧毁袁绍粮草，最终击败袁绍，统一北方。';
    } else if (!response && questionLower.includes('桃园结义')) {
      response = '某与关羽、张飞于桃园中结为异姓兄弟，誓言"不求同年同月同日生，但求同年同月同日死"，共图大事。';
    } else if (!response && questionLower.includes('三顾茅庐')) {
      response = '某为请诸葛亮出山相助，曾三次前往隆中拜访。先生感某诚意，提出《隆中对》，为某规划了三分天下的战略。';
    } else if (!response && (questionLower.includes('长坂坡') || questionLower.includes('长坂坡之战'))) {
      response = '长坂坡之战，某率大军南下追击刘备。刘备军大败，但赵云单骑救主，保护幼主刘禅脱险。张飞据水断桥，喝退吾军，真乃猛将也。';
    }

    // 检查是否询问性格或品格 - 增强版，确保更精确匹配
    if (!response && (questionLower.includes('性格') || questionLower.includes('品格') || questionLower.includes('为人'))) {
      const personalities = {
        liuBei: '某素以仁义著称，宽以待人，重情重义，礼贤下士。常以"勿以恶小而为之，勿以善小而不为"自勉。',
        caoCao: '孤雄才大略，果断机智，唯才是举，不拘一格降人才。虽有人言孤"奸雄"，但孤为天下计，无怨无悔。',
        sunQuan: '孤承父兄余业，沉稳睿智，善于用人，守成之主。常以"能用众力，则无敌于天下矣；能用众智，则无畏于圣人矣"自勉。'
      };
      response = personalities[character] || response;
    }

    // 增加更多常见关键词匹配 - 新增部分
    if (!response) {
      // 根据当前角色增加特定的关键词响应
      const characterSpecificKeywords = {
        liuBei: {
          '汉中': '汉中之战，某亲率大军与曹操争夺汉中。法正献计，黄忠斩夏侯渊，终得汉中之地，进位汉中王。',
          '夷陵之战': '夷陵之战，某为报云长之仇，举兵伐吴，却被陆逊火烧连营七百里，大败而归。此乃某生平最大之败也。',
          '白帝城托孤': '某兵败夷陵后，退至白帝城，将幼主刘禅托付于丞相诸葛亮，言"若嗣子可辅，辅之；如其不才，君可自取"。'
        },
        caoCao: {
          '东临碣石': '东临碣石，以观沧海。水何澹澹，山岛竦峙。树木丛生，百草丰茂。秋风萧瑟，洪波涌起。此乃某观沧海所作之诗也。',
          '铜雀台': '铜雀台乃某于邺城所建，高十丈，分三台，以彰显我大魏之威。台上珍藏许多书画珍宝，常与文人墨客宴饮赋诗于此。',
          '典韦': '典韦，陈留己吾人也。形貌魁梧，膂力过人，号"古之恶来"。为保护某而战死，某甚为痛惜。'
        },
        sunQuan: {
          '合肥之战': '合肥之战，某率十万大军攻打合肥，却被张辽率八百人突袭，几近被俘。此乃某生平之耻也。',
          '吕蒙': '吕蒙字子明，汝南富陂人也。由武夫变为儒将，"士别三日，当刮目相待"说的正是他。袭取荆州，擒杀关羽，立下大功。',
          '陆逊': '陆逊字伯言，吴郡吴县人也。夷陵之战中火烧连营，大败刘备。后任丞相，为吴国鞠躬尽瘁。'
        }
      };

      // 检查当前角色是否有特定关键词响应
      const characterKeywords = characterSpecificKeywords[character];
      if (characterKeywords) {
        for (const [keyword, keywordResponse] of Object.entries(characterKeywords)) {
          if (questionLower.includes(keyword)) {
            response = keywordResponse;
            break;
          }
        }
      }
    }

    // 如果找到了匹配的关键词响应，则直接返回
    if (response) {
      // 添加适当的前缀和结尾
      const prefixes = {
        liuBei: ['备以为', '某以为', '依某之见'],
        caoCao: ['孤以为', '操以为', '依孤之见'],
        sunQuan: ['孤以为', '权以为', '依孤之见']
      };

      const endings = {
        liuBei: '，不知先生以为如何？',
        caoCao: '，此乃孤之肺腑之言也！',
        sunQuan: '，还请将军指教。'
      };

      const prefix = prefixes[character][Math.floor(Math.random() * prefixes[character].length)];
      const ending = Math.random() < 0.3 ? endings[character] : '';

      return prefix + ' ' + response + ending;
    }

    // 分析问题类型
    let questionType = 'general';
    let maxScore = 0;

    // 为每个问题类型计算匹配分数
    for (const [type, keywords] of Object.entries(questionKeywords)) {
      const score = keywords.filter(keyword => questionLower.includes(keyword)).length;
      if (score > maxScore) {
        maxScore = score;
        questionType = type;
      }
    }

    // 选择合适的前缀
    let prefix = '';
    if (responseTypes[questionType]) {
      prefix = responseTypes[questionType][Math.floor(Math.random() * responseTypes[questionType].length)];
    }

    // 更智能的引用选择，尝试找到与问题更相关的引用
    const relatedQuotes = quotes.filter(quote => {
      // 检查引用是否包含问题中的关键词
      const quoteLower = quote.toLowerCase();
      // 提取问题中的关键词
      const questionWords = questionLower.split(/\s+/).filter(word => word.length > 1);
      // 计算匹配度
      const matchScore = questionWords.filter(word => quoteLower.includes(word)).length;
      return matchScore > 0;
    });

    // 选择回复内容
    let selectedQuote;
    if (relatedQuotes.length > 0) {
      // 如果找到相关引用，随机选择一个
      selectedQuote = relatedQuotes[Math.floor(Math.random() * relatedQuotes.length)];
    } else {
      // 否则随机选择一个通用引用
      selectedQuote = quotes[Math.floor(Math.random() * quotes.length)];
    }

    // 组合前缀和引用
    let finalResponse = prefix + selectedQuote;

    // 根据人物性格调整回复结尾
    const endings = {
      liuBei: '，不知先生以为如何？',
      caoCao: '，此乃孤之肺腑之言也！',
      sunQuan: '，还请将军指教。'
    };

    // 随机添加结尾（30%的概率）
    if (Math.random() < 0.3) {
      finalResponse += endings[character] || '';
    }

    return finalResponse;
  } catch (error) {
    console.error('生成模拟回复时出错:', error);

    // 返回一个更符合人物性格的默认回复
    const defaultResponses = {
      liuBei: '备当以仁义为本，以礼待人，愿闻先生高见。',
      caoCao: '夫英雄者，胸怀大志，腹有良谋，将军可有此等抱负？',
      sunQuan: '能用众力，则无敌于天下矣，孤当与江东父老共图大事。'
    };

    return defaultResponses[character] || '某以为此事尚需从长计议，将军以为如何？';
  }
}

// 解析JSON的辅助函数
function parseJson(body) {
  try {
    return JSON.parse(body);
  } catch (error) {
    return null;
  }
}

// 创建HTTP服务器
const server = http.createServer((req, res) => {
  // 设置CORS头
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');

  // 处理OPTIONS请求
  if (req.method === 'OPTIONS') {
    res.writeHead(204);
    res.end();
    return;
  }

  // 解析URL
  const parsedUrl = url.parse(req.url, true);
  const pathname = parsedUrl.pathname;

  // 健康检查接口
  if (pathname === '/api/health') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      status: 'ok',
      message: 'Server running (vanilla version)',
      timestamp: new Date().toISOString(),
      nodeVersion: process.version,
      serverType: 'vanilla (no dependencies)'
    }));
    return;
  }

  // 配置状态检查接口
  if (pathname === '/api/config/status') {
    try {
      // 优先检查Kimi API配置
      const hasKimiKey = !!process.env.KIMI_API_KEY && process.env.KIMI_API_KEY !== 'sk-XNyintct5hPgiPaj8IQ2r8cVoKxbz7X3YFCS52zEvfMzTJp7';
      const hasKimiBaseUrl = process.env.KIMI_API_BASE_URL && process.env.KIMI_API_BASE_URL !== 'https://api.moonshot.cn/v1/chat/completions';

      // 检查其他API配置
      const hasLiuBeiKey = !!process.env.AI_API_KEY_LIU_BEI && process.env.AI_API_KEY_LIU_BEI !== 'your_api_key_here';
      const hasCaoCaoKey = !!process.env.AI_API_KEY_CAO_CAO && process.env.AI_API_KEY_CAO_CAO !== 'your_api_key_here';
      const hasSunQuanKey = !!process.env.AI_API_KEY_SUN_QUAN && process.env.AI_API_KEY_SUN_QUAN !== 'your_api_key_here';

      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        hasApiKeys: hasKimiKey || hasLiuBeiKey || hasCaoCaoKey || hasSunQuanKey,
        keyStatus: {
          kimi: hasKimiKey ? 'configured' : 'missing',
          liuBei: hasLiuBeiKey ? 'configured' : 'missing',
          caoCao: hasCaoCaoKey ? 'configured' : 'missing',
          sunQuan: hasSunQuanKey ? 'configured' : 'missing'
        },
        apiBaseUrl: process.env.KIMI_API_BASE_URL || process.env.AI_API_BASE_URL || 'not configured',
        hasValidBaseUrl: hasKimiBaseUrl || (process.env.AI_API_BASE_URL && process.env.AI_API_BASE_URL !== 'https://api.example.com/v1/chat/completions'),
        lastChecked: new Date().toISOString(),
        serverType: 'vanilla'
      }));
    } catch (error) {
      res.writeHead(500, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        error: '配置检查内部错误',
        details: error.message
      }));
    }
    return;
  }

  // 聊天消息接口
  if (pathname === '/api/chat/message' && req.method === 'POST') {
    let body = '';

    req.on('data', chunk => {
      body += chunk.toString();
    });

    req.on('end', async () => {
      try {
        const data = parseJson(body);



        // 安全检查：确保character是有效的
        const validCharacters = ['liuBei', 'caoCao', 'sunQuan'];
        if (!validCharacters.includes(data.character)) {
          res.writeHead(400, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({
            success: false,
            error: 'Invalid character'
          }));
          return;
        }

        // 检查是否有API密钥配置
        let apiKey = null;
        if (process.env?.DEEPSEEK_API_KEY && process.env.DEEPSEEK_API_KEY !== 'your_deepseek_api_key_here') {
          apiKey = process.env.DEEPSEEK_API_KEY;
        } else {
          // 如果没有DeepSeek API密钥，则尝试使用特定人物的API密钥
          const apiKeys = {
            liuBei: process.env?.AI_API_KEY_LIU_BEI,
            caoCao: process.env?.AI_API_KEY_CAO_CAO,
            sunQuan: process.env?.AI_API_KEY_SUN_QUAN
          };
          apiKey = apiKeys[data.character] || null;

          // 检查是否是默认值或示例值
          if (apiKey && (apiKey === 'your_api_key_here' || apiKey === 'oHGZP6XFRvOv1TxX' || apiKey === '1fEFDnCi11n6RFW1' || apiKey === 'X4hg6WN1XKeHgg5T')) {
            apiKey = null;
          }
        }

        // 尝试使用Kimi API获取回复，如果失败则使用模拟回复作为备选
        let aiResponse;
        try {
          // 检查是否有Kimi API密钥
          if (process.env?.KIMI_API_KEY && process.env.KIMI_API_KEY.startsWith('sk-')) {
            console.log('使用Kimi API获取回复...');
            aiResponse = await callKimiApi(data.character, data.userMessage);
            console.log('Kimi API调用成功');
          } else {
            console.log('未找到有效的Kimi API密钥，使用模拟回复');
            aiResponse = generateMockResponse(data.character, data.userMessage);
          }
        } catch (apiError) {
          console.error('Kimi API调用失败，使用模拟回复作为备选:', apiError.message);
          aiResponse = generateMockResponse(data.character, data.userMessage);
        }

        // 模拟API延迟，让用户体验更自然
        await new Promise(resolve => setTimeout(resolve, 800));

        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: true,
          response: aiResponse
        }));
      } catch (error) {
        res.writeHead(500, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
          success: false,
          error: 'Internal server error',
          details: error.message
        }));
      }
    });

    return;
  }

  // 获取人物列表接口
  if (pathname === '/api/chat/characters' && req.method === 'GET') {
    const characters = [
      { id: 'liuBei', name: '刘备', description: '刘备（161年－223年），字玄德，东汉末年幽州涿郡涿县人，三国时期蜀汉开国皇帝。' },
      { id: 'caoCao', name: '曹操', description: '曹操（155年－220年），字孟德，东汉末年杰出的政治家、军事家、文学家、书法家。' },
      { id: 'sunQuan', name: '孙权', description: '孙权（182年－252年），字仲谋，吴郡富春人，三国时期孙吴的建立者。' }
    ];

    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      success: true,
      characters
    }));
    return;
  }

  // 处理404
  res.writeHead(404, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    success: false,
    error: 'Not found'
  }));
});

// 启动服务器
server.listen(PORT, () => {
  console.log('');
  console.log('🚀 三国风云对话 - 无依赖后端服务已启动');
  console.log(`🌐 服务运行在端口: ${PORT}`);
  console.log('🔧 服务器类型: 纯Node.js (无第三方依赖)');
  console.log('');
  console.log('========== 启动顺序 ==========');
  console.log('✅ 1. 后端服务已启动 (当前终端)');
  console.log('👉 2. 请打开另一个终端，运行: npm run start:client');
  console.log('👉 3. 然后在浏览器中访问: http://localhost:3000');
  console.log('=============================');
  console.log('');
  console.log('🔴 【重要警告】请务必使用 http://localhost:3000 访问应用');
  console.log('🔴 不要使用IP地址(如 http://10.12.122.176:3000)访问，否则会导致无法连接后端服务');
  console.log('');
  console.log('💡 故障排除:');
  console.log('1. 检查前端服务是否已启动: 运行 npm run test-frontend');
  console.log('2. 检查后端服务是否已启动: 运行 npm run test-backend');
  console.log('3. 查看完整帮助: 运行 npm run help');
  console.log('4. 如果端口被占用，尝试: set PORT=5001 && npm run start');
  console.log('');
  console.log('🎯 调试页面: http://localhost:3000/debug');
  console.log('');
});

// 处理服务器错误
server.on('error', (error) => {
  console.error('服务器错误:', error);

  // 提供友好的错误提示
  if (error.code === 'EADDRINUSE') {
    console.error(`端口 ${PORT} 已被占用，请关闭占用该端口的程序或使用其他端口`);
    console.error(`可以尝试: set PORT=5001 && node vanilla-server.js`);
  }
});

// 优雅退出
process.on('SIGINT', () => {
  console.log('\n正在关闭服务器...');
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
});